Preverjanje veljavnosti JavaScript Proxy Handler: Tipsko varno prestrezanje objektov

JavaScript Proxies zagotavljajo močan mehanizem za prestrezanje in prilagajanje temeljnih operacij z objekti. Ena izmed najbolj prepričljivih uporab je preverjanje veljavnosti podatkov. Z uporabo Proxy handlerjev lahko uveljavljate omejitve in tipsko varnost na lastnostih objekta, kar vodi do bolj robustne in vzdržljive kode. Ta objava na blogu raziskuje, kako uporabiti JavaScript Proxies za učinkovito preverjanje veljavnosti objektov, ter ponuja praktične primere in smernice za razvijalce vseh ravni. Obravnavali bomo različne metode handlerjev in prikazali, kako jih je mogoče uporabiti za zagotavljanje celovitosti podatkov.

Razumevanje JavaScript Proxies

Preden se potopimo v preverjanje veljavnosti, si na kratko oglejmo, kaj so JavaScript Proxies in kako delujejo. Proxy objekt obdaja drug objekt (cilj) in prestreza operacije, ki se izvajajo na tem cilju. Proxy vam omogoča, da definirate vedenje po meri za operacije, kot so pridobivanje lastnosti, nastavljanje lastnosti, klicanje funkcije ali konstruiranje novega objekta. To prilagajanje je doseženo prek handlerja, ki je objekt, ki vsebuje metode, ki prestrezajo specifične operacije.

Osnovna sintaksa za ustvarjanje Proxy je:

            const proxy = new Proxy(target, handler);
            

              
                Copy
              
            
          

• target: Objekt, ki ga želite obdati s Proxy.
• handler: Objekt, ki vsebuje metode (pasti), ki prestrezajo operacije na cilju.

Proxy Handler Metode za preverjanje veljavnosti

Objekt handler lahko vsebuje različne metode, od katerih vsaka ustreza drugi operaciji na ciljnem objektu. Tukaj je nekaj najpomembnejših metod za preverjanje veljavnosti:

• get(target, property, receiver): Prestreza dostop do lastnosti.
• set(target, property, value, receiver): Prestreza dodelitev lastnosti.
• apply(target, thisArg, argumentsList): Prestreza klice funkcij.
• construct(target, argumentsList, newTarget): Prestreza operator new.
• deleteProperty(target, property): Prestreza operator delete.
• defineProperty(target, property, descriptor): Prestreza definicijo lastnosti.
• has(target, property): Prestreza operator in.
• ownKeys(target): Prestreza Object.getOwnPropertyNames(), Object.getOwnPropertySymbols() in Reflect.ownKeys().
• preventExtensions(target): Prestreza Object.preventExtensions().
• getPrototypeOf(target): Prestreza Object.getPrototypeOf().
• setPrototypeOf(target, prototype): Prestreza Object.setPrototypeOf().

Osredotočili se bomo predvsem na handlerje get, set, apply in construct, saj se najpogosteje uporabljajo za namene preverjanja veljavnosti.

Preverjanje dodelitev lastnosti z handlerjem set

Handler set je ključen za preverjanje dodelitev lastnosti. Omogoča vam prestrezanje poskusov spreminjanja lastnosti objekta in uveljavljanje omejitev, preden se dodelitev dejansko zgodi.

Primer: Preverjanje tipa

Ustvarimo Proxy, ki uveljavlja preverjanje tipa za lastnosti objekta Person. Zagotovili bomo, da je name vedno niz, age pa vedno število.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'name' && typeof value !== 'string') {
      throw new TypeError('Name must be a string');
    }
    if (property === 'age' && typeof value !== 'number') {
      throw new TypeError('Age must be a number');
    }
    // The following line is crucial for ensuring the property is actually set.
    target[property] = value;
    return true; // Indicate success
  }
};

const proxy = new Proxy(person, validator);

proxy.name = 'Jane Smith'; // Works fine
proxy.age = 25; // Works fine

try {
  proxy.age = '40'; // Throws TypeError
} catch (e) {
  console.error(e);
}

console.log(proxy.age); // Output: 25

            

              
                Copy
              
            
          

V tem primeru handler set preveri tip vrednosti, ki je dodeljena name in age. Če je tip napačen, vrže TypeError, ki preprečuje dodelitev. Bistveno je, da vključite `target[property] = value;` v handler, da dejansko nastavite vrednost; sicer se lastnost ne bo posodobila.

Primer: Preverjanje obsega

Prav tako lahko preverimo, ali je lastnost znotraj določenega obsega. Na primer, zagotovimo, da je age vedno med 0 in 120.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'age') {
      if (typeof value !== 'number') {
        throw new TypeError('Age must be a number');
      }
      if (value < 0 || value > 120) {
        throw new RangeError('Age must be between 0 and 120');
      }
    }
    target[property] = value;
    return true;
  }
};

const proxy = new Proxy(person, validator);

proxy.age = 50; // Works fine

try {
  proxy.age = -5; // Throws RangeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Preverjanje dostopa do lastnosti z handlerjem get

Čeprav je manj pogost za strogo preverjanje veljavnosti, se lahko handler get uporablja za izvajanje transformacij ali preverjanj veljavnosti, ko se dostopa do lastnosti. Na primer, morda boste želeli oblikovati telefonsko številko ali zagotoviti, da je datum veljaven, preden ga vrnete.

Primer: Lastnosti samo za branje

Lahko simulirate lastnosti samo za branje tako, da vržete napako, ko nekdo poskuša dostopati do lastnosti, ki je ne bi smel brati neposredno.

            const config = {
  apiKey: 'secret_key'
};

const validator = {
  get: function(target, property) {
    if (property === 'apiKey') {
      throw new Error('Cannot directly access apiKey. Use a secure method.');
    }
    return target[property];
  }
};

const proxy = new Proxy(config, validator);

try {
  console.log(proxy.apiKey); // Throws Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Ta pristop preprečuje neposreden dostop do občutljivih podatkov in sili razvijalce, da uporabijo bolj nadzorovan način za pridobivanje ključa (npr. funkcijo, ki obravnava preverjanje pristnosti).

Preverjanje klicev funkcij z handlerjem apply

Handler apply vam omogoča, da prestrežete klice funkcij in preverite argumente, posredovane funkciji. To je še posebej uporabno za zagotavljanje, da funkcije prejmejo pravilne tipe in število argumentov.

Primer: Preverjanje tipa argumenta

Ustvarimo Proxy, ki preveri argumente, posredovane funkciji, ki izračuna površino pravokotnika.

            function calculateArea(width, height) {
  return width * height;
}

const validator = {
  apply: function(target, thisArg, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('calculateArea requires exactly two arguments: width and height.');
    }

    const width = argumentsList[0];
    const height = argumentsList[1];

    if (typeof width !== 'number' || typeof height !== 'number') {
      throw new TypeError('Width and height must be numbers.');
    }

    if (width <= 0 || height <= 0) {
      throw new RangeError('Width and height must be positive values.');
    }

    return target.apply(thisArg, argumentsList);
  }
};

const proxy = new Proxy(calculateArea, validator);

console.log(proxy(5, 10)); // Output: 50

try {
  console.log(proxy(5)); // Throws Error
} catch (e) {
  console.error(e);
}

try {
  console.log(proxy('5', 10)); // Throws TypeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

V tem primeru handler apply preveri število in tipe argumentov, posredovanih funkciji calculateArea. Če so argumenti neveljavni, vrže napako, preden se funkcija dejansko izvede. Ključna vrstica `return target.apply(thisArg, argumentsList);` dejansko izvede prvotno funkcijo s posredovanimi argumenti.

Preverjanje gradnje objekta z handlerjem construct

Handler construct vam omogoča, da prestrežete operator new in preverite argumente, posredovane konstruktorski funkciji. To je še posebej uporabno za uveljavljanje omejitev na objektih, ustvarjenih s konstruktorji.

Primer: Zahtevane lastnosti

Ustvarimo Proxy, ki zagotavlja, da je objekt User vedno ustvarjen z username in email.

            class User {
  constructor(username, email) {
    this.username = username;
    this.email = email;
  }
}

const validator = {
  construct: function(target, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('User constructor requires two arguments: username and email.');
    }

    const username = argumentsList[0];
    const email = argumentsList[1];

    if (typeof username !== 'string' || username.length === 0) {
      throw new TypeError('Username must be a non-empty string.');
    }

    if (typeof email !== 'string' || !email.includes('@')) {
      throw new TypeError('Email must be a valid email address.');
    }

    return new target(...argumentsList);
  }
};

const UserProxy = new Proxy(User, validator);

const user1 = new UserProxy('john.doe', 'john.doe@example.com'); // Works fine

try {
  const user2 = new UserProxy('john.doe'); // Throws Error
} catch (e) {
  console.error(e);
}

try {
  const user3 = new UserProxy('john.doe', 'invalid_email'); // Throws TypeError
} catch (e) {
  console.error(e);
}

console.log(user1);

            

              
                Copy
              
            
          

V tem primeru handler construct preveri število in tipe argumentov, posredovanih konstruktorju User. Če so argumenti neveljavni, vrže napako, preden se objekt ustvari. Vrstica `return new target(...argumentsList);` dejansko ustvari novo instanco razreda s posredovanimi argumenti.

Napredne tehnike preverjanja veljavnosti

Poleg osnovnega preverjanja tipa in obsega se lahko Proxies uporabljajo za naprednejše scenarije preverjanja veljavnosti.

Preverjanje veljavnosti med lastnostmi

S Proxies lahko preverite veljavnost razmerij med različnimi lastnostmi. Na primer, morda boste želeli zagotoviti, da je začetni datum vedno pred končnim datumom.

            const event = {
  startDate: '2024-01-15',
  endDate: '2024-01-20'
};

const validator = {
  set: function(target, property, value) {
    target[property] = value; // Set the value first

    if (property === 'endDate' && target.startDate > target.endDate) {
      throw new Error('End date must be after start date.');
    }

    return true;
  }
};

const proxy = new Proxy(event, validator);

proxy.endDate = '2024-01-25'; // Works fine

try {
  proxy.endDate = '2024-01-10'; // Throws Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Asinhrono preverjanje veljavnosti

Čeprav je manj pogosto, lahko uporabite Proxies z asinhronimi operacijami za bolj zapletene scenarije preverjanja veljavnosti. To lahko vključuje izvajanje klicev API za preverjanje veljavnosti podatkov glede na zunanje vire.

Pomembna opomba: Asinhrone operacije znotraj Proxy handlerjev so lahko zapletene in jih je treba obravnavati previdno, da se izognete blokiranju zanke dogodkov. Pogosto je bolje, da asinhrono preverjanje veljavnosti izvedete zunaj Proxy handlerja in nato uporabite Proxy za uveljavljanje rezultatov.

Prednosti uporabe Proxies za preverjanje veljavnosti

• Centralizirana logika preverjanja veljavnosti: Proxies vam omogočajo centralizacijo logike preverjanja veljavnosti na enem mestu, kar olajša vzdrževanje in posodabljanje.
• Izboljšana berljivost kode: Z ločitvijo logike preverjanja veljavnosti od osnovne logike objekta lahko izboljšate berljivost in vzdržljivost kode.
• Izboljšana tipski varnost: Proxies pomagajo uveljavljati tipsko varnost, kar zmanjšuje tveganje napak, ki jih povzročajo napačni tipi podatkov.
• Prilagodljivost in prilagajanje: Proxies zagotavljajo visoko stopnjo prilagodljivosti, kar vam omogoča, da prilagodite pravila preverjanja veljavnosti, da ustrezajo posebnim potrebam vaše aplikacije.

Omejitve uporabe Proxies

• Dodatni stroški učinkovitosti delovanja: Proxies uvajajo majhne dodatne stroške učinkovitosti delovanja zaradi prestrezanja operacij z objekti. Ti stroški so običajno zanemarljivi za večino aplikacij, vendar jih je pomembno upoštevati v scenarijih, ki so kritični za učinkovitost delovanja.
• Združljivost: Medtem ko so Proxies podprti v sodobnih brskalnikih in Node.js, niso podprti v starejših okoljih. Morda boste morali uporabiti polyfills, da zagotovite združljivost s starejšimi brskalniki.
• Odpravljanje napak: Odpravljanje napak v kodi, ki uporablja Proxies, je lahko nekoliko bolj zahtevno zaradi prestrezanja operacij z objekti. Vendar pa sodobna orodja za razvijalce zagotavljajo dobro podporo za odpravljanje napak v Proxies.

Najboljša praksa za preverjanje veljavnosti Proxy Handler

• Ohranite handlerje preproste: Izogibajte se zapleteni logiki znotraj Proxy handlerjev, da zmanjšate dodatne stroške učinkovitosti delovanja in izboljšate berljivost.
• Zagotovite jasna sporočila o napakah: Vrzite informativna sporočila o napakah, ki razvijalcem pomagajo razumeti, zakaj je preverjanje veljavnosti spodletelo.
• Upoštevajte učinkovitost delovanja: Bodite pozorni na vpliv Proxies na učinkovitost delovanja, zlasti v aplikacijah, ki so kritične za učinkovitost delovanja.
• Uporabljajte previdno: Ne prekomerno uporabljajte Proxies. Uporabljajte jih strateško za preverjanje veljavnosti in druge metaprogramske naloge, kjer zagotavljajo jasno korist.
• Temeljito testirajte: Temeljito testirajte logiko preverjanja veljavnosti, ki temelji na Proxies, da zagotovite, da deluje, kot pričakovano, v vseh scenarijih.

Globalni vidiki preverjanja veljavnosti

Pri razvoju aplikacij za globalno občinstvo je bistveno upoštevati kulturne razlike in regionalne različice pri izvajanju pravil preverjanja veljavnosti. Tukaj je nekaj ključnih vidikov:

• Formati datuma in časa: Uporabite knjižnico, kot je Moment.js ali date-fns, da pravilno obravnavate formate datuma in časa za različne jezike. Na primer, v Združenih državah Amerike so datumi pogosto oblikovani kot MM/DD/YYYY, medtem ko so v Evropi običajno oblikovani kot DD/MM/YYYY.
• Formati števil: Zavedajte se različnih formatov števil, vključno z decimalnimi ločili in ločili tisočic. V nekaterih državah se vejica uporablja kot decimalno ločilo, v drugih pa pika.
• Formati valut: Prikazujte vrednosti valut v pravilnem formatu za uporabnikov jezik, vključno z ustreznim simbolom valute in decimalno natančnostjo.
• Formati naslovov: Formati naslovov se po svetu zelo razlikujejo. Razmislite o uporabi knjižnice ali API-ja, ki podpira mednarodno preverjanje veljavnosti in oblikovanje naslovov.
• Formati telefonskih številk: Uporabite knjižnico, ki podpira mednarodno preverjanje veljavnosti in oblikovanje telefonskih številk, da zagotovite, da so telefonske številke vnesene pravilno.
• Formati imen: Zavedajte se, da se formati imen lahko razlikujejo med kulturami. Nekatere kulture uporabljajo ime, ki mu sledi priimek, medtem ko druge uporabljajo priimek, ki mu sledi ime. Prav tako imajo nekatere kulture več imen ali priimkov.
• Nabori znakov: Zagotovite, da vaša aplikacija podpira različne nabore znakov in kodiranja, da lahko sprejme imena, naslove in druge besedilne podatke v različnih jezikih.
• Kulturna občutljivost: Bodite pozorni na kulturno občutljivost pri oblikovanju pravil preverjanja veljavnosti. Na primer, nekatere vrste podatkov se lahko v nekaterih kulturah štejejo za zasebne ali občutljive.

Primer: Mednarodno preverjanje veljavnosti telefonske številke

            // Assuming you're using a library like "google-libphonenumber"

import { parsePhoneNumberFromString, AsYouType } from 'google-libphonenumber';

function validatePhoneNumber(phoneNumber, countryCode) {
  try {
    const number = parsePhoneNumberFromString(phoneNumber, countryCode);
    if (number && number.isValid()) {
      return true;
    } else {
      return false;
    }
  } catch (error) {
    return false; // Invalid phone number format
  }
}

// Example Usage (Germany)
const isValidGermanNumber = validatePhoneNumber('+4917612345678', 'DE');
console.log('Is valid German number:', isValidGermanNumber); // Output: true

// Example Usage (United States)
const isValidUSNumber = validatePhoneNumber('+15551234567', 'US');
console.log('Is valid US number:', isValidUSNumber); // Output: true

            

              
                Copy
              
            
          

Zaključek

JavaScript Proxies zagotavljajo močan in prilagodljiv mehanizem za izvajanje logike preverjanja veljavnosti v vaših aplikacijah. Z uporabo Proxy handlerjev lahko uveljavljate omejitve in tipsko varnost na lastnostih objekta, argumentih funkcij in gradnji objekta, kar vodi do bolj robustne, vzdržljive in varne kode. Ne pozabite upoštevati vpliva na učinkovitost delovanja in težav z združljivostjo pri uporabi Proxies ter vedno temeljito testirajte logiko preverjanja veljavnosti. Z upoštevanjem najboljših praks, opisanih v tej objavi na blogu, lahko učinkovito uporabite Proxies za izboljšanje kakovosti in zanesljivosti vaših aplikacij JavaScript, ki ustrezajo globalnemu občinstvu z lokaliziranimi strategijami preverjanja veljavnosti.